package com.dd.service.impl;

import com.dd.mapper.ProductMapper;
import com.dd.model.Product;
import com.dd.service.ProductService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * 商品服务实现类
 */
@Service
public class ProductServiceImpl implements ProductService {
    
    private static final Logger logger = LoggerFactory.getLogger(ProductServiceImpl.class);
    
    // Redis缓存key前缀
    private static final String CACHE_KEY_PREFIX = "product:";
    private static final String CACHE_KEY_ALL = "product:all";
    private static final String CACHE_KEY_CATEGORY = "product:category:";
    private static final String CACHE_KEY_NAME = "product:name:";
    
    // 缓存过期时间（30分钟）
    private static final long CACHE_EXPIRE_TIME = 30;
    
    @Value("${redis.enabled}")
    private boolean redisEnabled;
    
    @Autowired
    private ProductMapper productMapper;
    
    @Autowired(required = false)
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 检查Redis是否可用
     */
    private boolean isRedisAvailable() {
        return redisEnabled && redisTemplate != null;
    }
    
    @Override
    public List<Product> findAllProducts() {
        // 如果Redis未启用，直接从数据库获取
        if (!isRedisAvailable()) {
            logger.info("Redis未启用，从数据库获取所有商品数据");
            return productMapper.findAll();
        }
        
        try {
            // 尝试从缓存获取
            @SuppressWarnings("unchecked")
            List<Product> products = (List<Product>) redisTemplate.opsForValue().get(CACHE_KEY_ALL);
            
            if (products != null) {
                logger.info("从缓存获取所有商品数据");
                return products;
            }
            
            // 缓存未命中，从数据库获取
            logger.info("从数据库获取所有商品数据");
            products = productMapper.findAll();
            
            // 存入缓存
            redisTemplate.opsForValue().set(CACHE_KEY_ALL, products, CACHE_EXPIRE_TIME, TimeUnit.MINUTES);
            
            return products;
        } catch (Exception e) {
            logger.error("Redis操作异常，从数据库获取所有商品数据", e);
            return productMapper.findAll();
        }
    }
    
    @Override
    public Product getProductById(Integer productId) {
        // 如果Redis未启用，直接从数据库获取
        if (!isRedisAvailable()) {
            logger.info("Redis未启用，从数据库获取商品数据，ID: {}", productId);
            return productMapper.findById(productId);
        }
        
        try {
            String cacheKey = CACHE_KEY_PREFIX + productId;
            
            // 尝试从缓存获取
            Product product = (Product) redisTemplate.opsForValue().get(cacheKey);
            
            if (product != null) {
                logger.info("从缓存获取商品数据，ID: {}", productId);
                return product;
            }
            
            // 缓存未命中，从数据库获取
            logger.info("从数据库获取商品数据，ID: {}", productId);
            product = productMapper.findById(productId);
            
            if (product != null) {
                // 存入缓存
                redisTemplate.opsForValue().set(cacheKey, product, CACHE_EXPIRE_TIME, TimeUnit.MINUTES);
            }
            
            return product;
        } catch (Exception e) {
            logger.error("Redis操作异常，从数据库获取商品数据，ID: {}", productId, e);
            return productMapper.findById(productId);
        }
    }
    
    @Override
    public List<Product> findProductsByCategory(String category) {
        // 如果Redis未启用，直接从数据库获取
        if (!isRedisAvailable()) {
            logger.info("Redis未启用，从数据库获取分类商品数据，分类: {}", category);
            return productMapper.findByCategory(category);
        }
        
        try {
            String cacheKey = CACHE_KEY_CATEGORY + category;
            
            // 尝试从缓存获取
            @SuppressWarnings("unchecked")
            List<Product> products = (List<Product>) redisTemplate.opsForValue().get(cacheKey);
            
            if (products != null) {
                logger.info("从缓存获取分类商品数据，分类: {}", category);
                return products;
            }
            
            // 缓存未命中，从数据库获取
            logger.info("从数据库获取分类商品数据，分类: {}", category);
            products = productMapper.findByCategory(category);
            
            // 存入缓存
            redisTemplate.opsForValue().set(cacheKey, products, CACHE_EXPIRE_TIME, TimeUnit.MINUTES);
            
            return products;
        } catch (Exception e) {
            logger.error("Redis操作异常，从数据库获取分类商品数据，分类: {}", category, e);
            return productMapper.findByCategory(category);
        }
    }
    
    @Override
    public List<Product> findProductsByName(String name) {
        // 如果Redis未启用，直接从数据库获取
        if (!isRedisAvailable()) {
            logger.info("Redis未启用，从数据库获取商品搜索结果，关键词: {}", name);
            return productMapper.findByNameLike(name);
        }
        
        try {
            String cacheKey = CACHE_KEY_NAME + name;
            
            // 尝试从缓存获取
            @SuppressWarnings("unchecked")
            List<Product> products = (List<Product>) redisTemplate.opsForValue().get(cacheKey);
            
            if (products != null) {
                logger.info("从缓存获取商品搜索结果，关键词: {}", name);
                return products;
            }
            
            // 缓存未命中，从数据库获取
            logger.info("从数据库获取商品搜索结果，关键词: {}", name);
            products = productMapper.findByNameLike(name);
            
            // 存入缓存，搜索结果缓存时间较短（10分钟）
            redisTemplate.opsForValue().set(cacheKey, products, 10, TimeUnit.MINUTES);
            
            return products;
        } catch (Exception e) {
            logger.error("Redis操作异常，从数据库获取商品搜索结果，关键词: {}", name, e);
            return productMapper.findByNameLike(name);
        }
    }
    
    @Override
    @Transactional
    public boolean addProduct(Product product) {
        boolean result = productMapper.insert(product) > 0;
        
        if (result && isRedisAvailable()) {
            // 清除相关缓存
            clearProductCache();
        }
        
        return result;
    }
    
    @Override
    @Transactional
    public boolean updateProduct(Product product) {
        boolean result = productMapper.update(product) > 0;
        
        if (result && isRedisAvailable()) {
            try {
                // 清除相关缓存
                clearProductCache();
                // 删除该商品的缓存
                redisTemplate.delete(CACHE_KEY_PREFIX + product.getProductId());
            } catch (Exception e) {
                logger.error("清除商品缓存失败", e);
                // 缓存操作失败不影响主业务
            }
        }
        
        return result;
    }
    
    @Override
    @Transactional
    public boolean deleteProduct(Integer productId) {
        boolean result = productMapper.deleteById(productId) > 0;
        
        if (result && isRedisAvailable()) {
            try {
                // 清除相关缓存
                clearProductCache();
                // 删除该商品的缓存
                redisTemplate.delete(CACHE_KEY_PREFIX + productId);
            } catch (Exception e) {
                logger.error("清除商品缓存失败", e);
                // 缓存操作失败不影响主业务
            }
        }
        
        return result;
    }
    
    @Override
    @Transactional
    public boolean updateProductStock(Integer productId, Integer stock) {
        boolean result = productMapper.updateStock(productId, stock) > 0;
        
        if (result && isRedisAvailable()) {
            try {
                // 删除该商品的缓存，让下次访问重新加载
                redisTemplate.delete(CACHE_KEY_PREFIX + productId);
                // 清除所有商品列表缓存
                redisTemplate.delete(CACHE_KEY_ALL);
            } catch (Exception e) {
                logger.error("清除商品缓存失败", e);
                // 缓存操作失败不影响主业务
            }
        }
        
        return result;
    }
    
    /**
     * 清除商品相关的缓存
     */
    private void clearProductCache() {
        if (!isRedisAvailable()) {
            return;
        }
        
        try {
            logger.info("清除商品缓存");
            
            // 删除所有商品列表缓存
            redisTemplate.delete(CACHE_KEY_ALL);
            
            // 删除分类商品缓存（使用模式匹配）
            Set<String> categoryKeys = redisTemplate.keys(CACHE_KEY_CATEGORY + "*");
            if (categoryKeys != null && !categoryKeys.isEmpty()) {
                redisTemplate.delete(categoryKeys);
            }
            
            // 删除搜索结果缓存
            Set<String> nameKeys = redisTemplate.keys(CACHE_KEY_NAME + "*");
            if (nameKeys != null && !nameKeys.isEmpty()) {
                redisTemplate.delete(nameKeys);
            }
        } catch (Exception e) {
            logger.error("清除商品缓存失败", e);
            // 缓存操作失败不影响主业务
        }
    }
} 